can you just do visit(iet.parameters) directly instead?

looks like not, since the actual types I'm mapping (e.g. Constant) aren't nodes they are only caught by FindSymbols if it's as a reference within some other expression, so we need to visit the body. That said I can probably make this marginally more efficient by making a set of parameters beforehand and checking membership that way

Now that's a bit tricky because this updates a global ctypes_vector_mapper which might lead to odd behavior building multiple operators with different languages.
Do you know where it's called and needs those types ? I.e can the mapper be "local" to the operator and passed there?

@ZoeLeibowitz I may be wrong but don't you need this type too? please see also where it's used and comment

We have different use cases because I need a local composite type which still generates a struct in the header file (i.e still produces a struct definition)

how can this not be an @iet_pass and still work?

It's called from an @iet_pass in definitions here

ah OK , I maybe have told Mathias already, but imho that thing goes straight into operator/operator.py::Operator::_lower_iet

Ah okay, I can make this change

The introduction of an override is a good idea here.

I think this wants separating out into a couple of tests:

• Test that the correct expressions are generated
• Test that you can specify derivatives of complex fields
• Test that you can override complex values
• Test that you can mix complex and real symbols on the RHS

Note: do we also need to test that halo exchanges work with complex?

Ok, will add some tests for those points.

Re: halo exchanges, I'll get back to you when I figure out what a halo exchange is

A halo exchange is where each MPI rank swaps the data along its edges with its neighbours before advancing to the next timestep. It would probably worth checking that the MPI communication doesn't garble the data somehow when moving it between ranks. You would probably need some equations like:

from devito import Grid, TimeFunction, Eq, Operator

grid = Grid(shape=(4, 4))
x, y = grid.dimensions
t = grid.stepping_dim

u = TimeFunction(name='u', grid=grid)
v = TimeFunction(name='v', grid=grid)

eqns = [Eq(u[t+1, x, y], 1+sympy.I), Eq(v[t+1, x, y], sympy.I*u[t, x, y+1])]

op = Operator(eqns)

Ok. I think what I'll do is leave these general complex arithmetic tests where they are (in test_operator and test_gpu_common) and add these lower-level ones to the test_dtypes module. Except this halo exchange one goes in test_mpi I guess